Grupo nº Infinito
Integrantes Daniel Ferreira Alves - dandastico.bsb@gmail.com
Prof. Orientador MSc. Edilberto M. Silva - prof.edilberto.silva@gmail.com
11/2025
O presente documento constitui o Plano de Projeto para o desenvolvimento do EduGit, um plug-in educacional para a plataforma Moodle. O objetivo primordial deste projeto é aprimorar a gestão e o fluxo de trabalho de atividades práticas de programação no ambiente acadêmico, especificamente para alunos e professores da Faculdade SENAC-DF.
O EduGit propõe-se a ser um sistema de controle de versão simplificado, integrado ao Moodle, que visa organizar e gerenciar os códigos-fonte desenvolvidos por alunos em suas atividades. Sua funcionalidade central reside na capacidade de simular um repositório na nuvem, similar ao GitHub, permitindo que os alunos submetam suas soluções via comandos simplificados de terminal.
Um diferencial estratégico do EduGit é a incorporação de uma plataforma de testes automatizados. Esta funcionalidade permitirá aos professores configurar testes unitários que serão executados automaticamente contra o código submetido pelos alunos. Este mecanismo tem o propósito de acelerar significativamente o processo de correção das atividades e fornecer feedback imediato e objetivo aos estudantes, alinhando-se a modelos de ensino de programação de alta performance.
Este Plano de Projeto detalha o escopo, os objetivos de alto nível, os requisitos funcionais, a estrutura de trabalho e o cronograma proposto para a entrega da primeira versão funcional do EduGit até o final do semestre letivo vigente (27/11/2025). O sucesso do projeto será medido pela sua capacidade de fornecer uma ferramenta robusta e eficiente que otimize o processo de ensino-aprendizagem de programação na instituição
EduGit
Funcionalidades Principais:
Limitações:
RF01 - Manter cadastro de usuário
RF02 - Gerenciar login do usuário
RF03 - Gerenciar atividades
RF04 - Gerenciar Submissões de Código
RF05 - Executar Testes Automatizados
erDiagram USUARIO { int id PK varchar nome varchar email UK varchar senha_hash varchar tipo_usuario varchar codigo_validacao datetime data_cadastro } CURSO_GRADUACAO { int id PK varchar nome_curso } TURMA { int id PK int curso_graduacao_id FK varchar nome_turma varchar semestre } TURMA_USUARIO { int usuario_id PK,FK int turma_id PK,FK varchar papel } ATIVIDADE { int id PK int turma_id FK varchar titulo text descricao datetime prazo_entrega varchar template_path int pontuacao_maxima } TESTE_UNITARIO { int id PK int atividade_id FK varchar nome_teste text codigo_teste int peso_pontuacao } SUBMISSAO { int id PK int usuario_id FK int atividade_id FK datetime data_submissao varchar arquivo_path float pontuacao_final } RESULTADO_TESTE { int id PK int submissao_id FK int teste_unitario_id FK boolean passou text log_erro float pontuacao_obtida } USUARIO ||--o{ TURMA_USUARIO : "pertence" TURMA ||--o{ TURMA_USUARIO : "contém" CURSO_GRADUACAO ||--o{ TURMA : "oferece" TURMA ||--o{ ATIVIDADE : "possui" ATIVIDADE ||--o{ SUBMISSAO : "recebe" USUARIO ||--o{ SUBMISSAO : "realiza" ATIVIDADE ||--o{ TESTE_UNITARIO : "configura" SUBMISSAO ||--o{ RESULTADO_TESTE : "gera" TESTE_UNITARIO ||--o{ RESULTADO_TESTE : "avalia"
[RF01] Manter cadastro de Usuário Registrar novo usuário com gestão própria.
Este requisito descreve todos os passos para realização do cadastro de um novo usuário no sistema em que o usuário insere nome, email e senha (todos salvos no MySQL, senha criptografada).
Verificação do e-mail para certificar de que o usuário é o verdadeiro proprietário da conta. O processo inclui o envio de um código de verificação de 6 dígitos numéricos aleatórios para o email enviado, validação do código e a possibilidade de reenviar o código de verificação.
Ator: Aluno, Professor
Prioridade:
RF01.1 Consultar Usuário
Consultar Usuário Permite que o usuário visualize seus dados cadastrais.
Resultado Esperado: O usuário consegue visualizar as informações do seu perfil de forma clara e organizada.
RF01.2 Cadastrar Usuário
Permite a criação de um novo registro de usuário no sistema, incluindo a coleta de e-mail e senha.
Resultado Esperado: Uma nova conta de usuário é criada e um email de confirmação é enviado para o endereço fornecido.
RF01.3 Validar Email
Processo de segurança que envolve a de um link, enviado para o e-mail cadastrado pelo usuário, para confirmar o e-mail do usuário.
Durante o cadastro (RF01.2), o usuário insere um endereço de email.
O sistema valida o formato do email em tempo real, verificando se:
Resultado Esperado: O email do usuário é validado e confirmado, permitindo o acesso pleno à plataforma.
RF01.4 Editar Usuário
Permite a modificação dos dados cadastrais de um usuário existente, como email e senha.
Resultado Esperado: As informações do usuário são atualizadas no sistema e refletidas imediatamente em seu perfil.
[RF02] Gerenciar login do usuário
Permitir que usuários autenticados acessem as funcionalidades do sistema.
Este requisito abrange o processo de autenticação do usuário no sistema, garantindo que apenas usuários cadastrados e validados possam acessar as áreas restritas. Inclui a validação das credenciais (e-mail/senha) e o mecanismo de recuperação de senha.
Ator: Aluno, Professor
Prioridade:
RF02.1 Validar Credencial
O sistema deve verificar se o e-mail e a senha fornecidos pelo usuário correspondem a um registro válido no banco de dados. A senha deve ser comparada após a criptografia.
Resultado Esperado: O usuário é autenticado e pode acessar a plataforma EduGit.
RF02.2 Redefinir Senha (esquecer a senha)
Permite que o usuário inicie um processo de recuperação de senha, geralmente envolvendo o envio de um link ou código de segurança para o e-mail cadastrado, para que possa definir uma nova senha.
[RF03] Gerenciar atividades
Permitir que o Professor crie, configure e gerencie as atividades acadêmicas que serão submetidas pelos alunos.
Este requisito é fundamental para o lado do Professor, permitindo a criação de um ambiente de submissão de código. O professor deve ser capaz de definir o escopo da atividade, o prazo, associar templates iniciais e configurar os testes unitários que serão usados na correção automática.
Ator: Professor
Prioridade:
RF03.1 Criar Atividade
Permite ao Professor definir o título, descrição e parâmetros básicos de uma nova atividade.
Resultado Esperado: Uma nova atividade é criada no sistema com status "Rascunho" e pronta para ser configurada.
RF03.2 Editar Atividade
Permite ao Professor modificar os detalhes de uma atividade que ainda não foi publicada ou que precisa de ajustes.
Resultado Esperado: Os detalhes da atividade são atualizados no sistema.
RF03.3 Excluir Atividade
Permite a remoção de uma atividade do sistema, desde que não haja submissões associadas ou que a exclusão seja permitida pelas regras de negócio.
Resultado Esperado: A atividade é removida do sistema de forma irreversível.
RF03.4 Publicar/Ocultar Atividade
Permite ao Professor controlar a visibilidade da atividade para os alunos, tornando-a disponível para submissão ou ocultando-a temporariamente.
Descrição: Este requisito permite que um professor controle a visibilidade de uma atividade, tornando-a disponível ou indisponível para os alunos.
Ator Principal: Professor
Prioridade: Essencial
Passo-a-Passo:
O professor acessa o menu "Atividades" e seleciona uma atividade.
O sistema exibe a página de detalhes da atividade com um botão "Publicar" (se o status for "Rascunho") ou "Ocultar" (se o status for "Publicada").
Se o professor clicar em "Publicar":
Resultado Esperado: O status da atividade é alterado, controlando sua visibilidade para os alunos.
RF03.5 Definir Prazo de Entrega
Permite ao Professor estabelecer a data e hora limite para a submissão dos códigos pelos alunos.
Durante a criação (RF03.1) ou edição (RF03.2) de uma atividade, o professor preenche o campo "Prazo de Entrega".
O sistema exibe um seletor de data e hora, permitindo que o professor escolha:
O professor seleciona a data e hora desejadas.
O sistema valida se a data/hora é futura (não pode ser uma data passada).
Se a data for inválida, o sistema exibe a mensagem: "O prazo deve ser uma data futura".
Se a data for válida, o sistema armazena o prazo no banco de dados.
Quando o prazo se aproxima, o sistema pode enviar notificações automáticas aos alunos (funcionalidade opcional).
Após o prazo expirar, o sistema:
Resultado Esperado: O prazo de entrega é definido e o sistema controla as submissões com base nele.
RF03.6 Configurar Template Inicial
Permite ao Professor anexar ou configurar um arquivo de código inicial (template) que os alunos poderão baixar via terminal para começar a atividade.
Durante a criação ou edição de uma atividade, o professor acessa a seção "Template Inicial".
O sistema exibe um editor de código ou um campo de upload de arquivo.
O professor pode:
O professor insere o código do template (ex: uma função com assinatura definida, mas corpo vazio).
O professor clica em "Salvar Template".
O sistema valida o código:
Se houver erros de validação, o sistema exibe mensagens de erro.
Se o código for válido, o sistema:
Resultado Esperado: Um template inicial é configurado e será fornecido aos alunos quando iniciarem a atividade.
RF03.7 Associar Testes Unitários à Atividade
Permite ao Professor vincular um conjunto de testes unitários (scripts de teste) que serão executados automaticamente contra o código submetido pelo aluno.
Durante a criação ou edição de uma atividade, o professor acessa a seção "Configurar Testes".
O sistema exibe uma interface para adicionar testes unitários.
O professor clica em "Adicionar Novo Teste".
O sistema exibe um formulário com os seguintes campos:
O professor preenche todos os campos.
O professor clica em "Salvar Teste".
O sistema valida o código do teste:
Se houver erros, o sistema exibe mensagens de erro.
Se o código for válido, o sistema armazena o teste no banco de dados e associa à atividade.
O professor pode adicionar múltiplos testes para a mesma atividade.
O sistema verifica se a soma dos pesos de todos os testes é 100%.
Quando um aluno submeter código (RF04.1), os testes configurados serão executados automaticamente (RF05.2).
Resultado Esperado: Testes unitários são configurados e serão executados automaticamente nas submissões dos alunos.
[RF04] Gerenciar Submissões de Código
Permitir que o Aluno envie seu código para correção e que o Professor visualize e gerencie essas submissões.
Este requisito cobre o fluxo de trabalho principal do aluno, que é a submissão do código via terminal. Inclui a validação do formato do arquivo e a capacidade do Professor de listar e baixar os códigos submetidos.
Ator: Aluno, Professor
Prioridade:
RF04.1 Enviar Código via Terminal
Permite ao Aluno executar um comando simplificado (e.g., edugit enviar) no terminal para fazer o upload do seu arquivo de código para o repositório do EduGit.
>>> edugit enviar atividade-maneira
Comando CLI inserido no terminal para enviar atividade
O aluno acessa a atividade no EduGit, copia o comando CLI para baixar a atividade e a executa em seu terminal.
O sistema fornece ao aluno:
O aluno trabalha localmente em seu computador, desenvolvendo a solução.
Quando o aluno termina, ele abre o terminal em seu computador.
O aluno navega até o diretório contendo seu código.
aluno executa o comando de submissão fornecido pelo EduGit:
O cliente EduGit (instalado no computador do aluno) valida o arquivo (veja RF04.2).
Se o arquivo for válido, o cliente envia o código para o servidor EduGit via HTTPS.
O servidor recebe o código e:
O servidor inicia automaticamente a execução dos testes (RF05.2).
O cliente exibe uma mensagem de sucesso: "Código enviado com sucesso! Os testes estão sendo executados...".
O aluno pode verificar o status da submissão acessando a atividade no EduGit.
Resultado Esperado: O código do aluno é enviado com sucesso e os testes são iniciados automaticamente.
RF04.2 Validar Formato do Código
O sistema deve verificar se o arquivo submetido está no formato esperado (inicialmente, apenas arquivos Python .py) e se atende a quaisquer outras regras de formato.
>>> Vertificando estrutura do código...
>>> Funções exigidas pela atividade encontradas...
>>> Envio concluído
Resposta do sistema visto pelo terminal do código validado de acordo com template do professor
>>> Verificando estrutura do código...
>>> Funcções exigidas não encontradas.
>>> Envio cancelado!
Resposta do sistema visto pelo terminal quando o código não foi validado de acordo com o template do professor
Quando um aluno tenta enviar código via terminal (RF04.1), o cliente EduGit valida o arquivo localmente.
O sistema verifica:
Se todas as validações passarem, o arquivo é aceito e enviado ao servidor.
O servidor também realiza validações adicionais:
Resultado Esperado: Apenas arquivos válidos são aceitos para submissão.
RF04.3 Listar Submissões por Aluno
Permite ao Professor visualizar um histórico de todas as submissões feitas por um aluno específico para uma determinada atividade.
O aluno acessa uma atividade no EduGit.
O aluno clica em "Meu Histórico de Submissões".
O sistema exibe uma tabela com todas as submissões do aluno para essa atividade, incluindo:
O aluno pode fazer quantas submissões desejar até o prazo (RF03.5).
O sistema mantém um histórico completo de todas as submissões.
Resultado Esperado: O aluno pode visualizar todas as suas submissões e seus resultados.
RF04.4 Download do Código Submetido
Permite ao Professor baixar o arquivo de código submetido por um aluno para análise manual, se necessário.
>>> edugit baixar atividade-maneira <nome do aluno>
Comando CLI para baixar código de um aluno específico, de uma atividade específica
O aluno acessa o histórico de submissões (RF04.3) ou o professor acessa a lista de submissões de uma atividade.
O usuário seleciona uma submissão específica.
O sistema exibe os detalhes da submissão com um botão "Baixar Código" ou executa comando no terminal.
O usuário clica em "Baixar Código".
O sistema:
O arquivo é salvo com um nome descritivo, ex: atividade_10_joao_silva_15_11_2025.py.
O sistema registra o download no histórico de atividades (para auditoria).
Resultado Esperado: O arquivo de código é baixado com sucesso para o computador do usuário.
[RF05] Executar Testes Automatizados
Realizar a correção automática do código submetido pelo Aluno com base nos testes unitários configurados pelo Professor.
Este requisito é o cerne da proposta de valor do EduGit, que é acelerar a correção. Ele detalha o processo de configuração, execução e geração de feedback dos testes unitários.
Ator: Professor (Configuração), Sistema (Execução), Aluno (Visualização do Feedback)
Prioridade:
RF05.1 Configurar Testes Unitários
Permite ao Professor fazer o upload ou definir o código dos testes unitários que serão usados para avaliar as submissões.
A inserção do código teste é realizado no mesmo local que a criação da ativdade, ou a edição dela
O professor acessa uma atividade e clica em "Configurar Testes".
O sistema exibe uma interface para gerenciar testes (detalhes em RF03.7).
O professor pode:
O professor clica em "Salvar Configuração de Testes".
O sistema valida a configuração:
Se houver erros, o sistema exibe mensagens de erro.
Se a configuração for válida, o sistema armazena os testes e ativa a execução automática.
Resultado Esperado: Os testes são configurados e prontos para serem executados nas submissões.
RF05.2 Executar Testes no Servidor
O sistema deve ser capaz de rodar o código submetido pelo aluno em um ambiente seguro (sandbox) contra os testes unitários associados à atividade.
O teste pode ser realizado das seguintes maneiras:
>>> edugit testar atividade-maneira
Enviando código...
Testando código...
Recebendo resultados...
--------------------------------------
:) Solução de acordo com o template do professor
:) Solução retorna uma string
:) Solução retorna "Daniel"
:) Solução retorna "Carol"
:( Esperava retorno com valor "Edilberto", não "Silva"
Performance: 4/5
-> Mais informações: https://edugit.com.br/testes/atividade-maneira123846513518
>>> edugit enviar atividade-maneira
Enviando código...
Analisando código...
Código armazenado com sucesso!
Recebendo resultados...
--------------------------------------
:) Solução de acordo com o template do professor
:) Solução retorna uma string
:) Solução retorna "Daniel"
:) Solução retorna "Carol"
:( Esperava retorno com valor "Edilberto", não "Silva"
Performance: 4/5
-> Mais informações: https://edugit.com.br/testes/atividade-maneira123846513518
>>> edugit enviar atividade-maneira
Enviando código...
Código armazenado com sucesso!
A solução será corrigida em: 27/11/2025
Mensagens no terminal após enviar a solução para uma atividade com os testes privados
Quando um aluno submete código (RF04.1), o servidor EduGit recebe o arquivo.
O servidor cria um ambiente isolado (sandbox/container) para executar os testes.
O servidor copia o arquivo de código do aluno para o ambiente isolado.
O servidor copia o arquivo de template (se houver) para o ambiente isolado.
O servidor copia os testes unitários configurados para o ambiente isolado.
O servidor executa cada teste unitário no ambiente isolado:
Se um teste falhar, o servidor captura a mensagem de erro.
Se um teste exceder um tempo limite de execução (ex: 30 segundos), o servidor interrompe a execução e marca como "Timeout".
O servidor limpa o ambiente isolado após a execução.
O servidor armazena os resultados no banco de dados.
O servidor inicia a geração do relatório de testes (RF05.3).
Resultado Esperado: Os testes são executados com segurança em um ambiente isolado e os resultados são registrados.
RF05.3 Gerar Relatórios de Testes
Após a execução, o sistema deve compilar um relatório detalhado indicando quais testes passaram e quais falharam, e a razão da falha.
Relatório gerado pelo sistema, disponível no Moodle
Após a execução dos testes (RF05.2), o servidor gera um relatório.
O relatório inclui:
O relatório é armazenado no banco de dados e associado à submissão.
O relatório é exibido ao aluno na interface web:
Resultado Esperado: Um relatório detalhado dos testes é gerado e disponibilizado ao aluno e ao professor.
RF05.4 Definir Casos de Testes
Permite ao Professor especificar os diferentes cenários de entrada e saída esperada para cada teste unitário.
Durante a configuração de testes (RF05.1 ou RF03.7), o professor define casos de teste.
Para cada teste, o professor pode definir múltiplos casos de teste:
O professor pode adicionar quantos casos de teste desejar.
O professor clica em "Salvar Casos de Teste".
O sistema valida os casos de teste:
Se houver erros, o sistema exibe mensagens de erro.
Se forem válidos, o sistema armazena os casos de teste.
Durante a execução dos testes (RF05.2), cada caso de teste é executado:
Resultado Esperado: Casos de teste são definidos e executados para validar o código do aluno.
RF05.5 Calcular Pontuação Automática
Com base no número de testes unitários que passaram, o sistema deve calcular automaticamente uma pontuação para a submissão do aluno.
Após a execução de todos os testes (RF05.2), o servidor calcula a pontuação.
O cálculo é realizado da seguinte forma:
O servidor armazena a pontuação no banco de dados.
O servidor atualiza o livro de notas do Moodle (se integrado) com a pontuação.
O aluno visualiza sua pontuação:
Resultado Esperado: A pontuação do aluno é calculada automaticamente com base no desempenho nos testes.
flowchart TD A[Aluno abre terminal] --> B[Digita comando<br>'edugit enviar atividade1'] B --> C{Sistema verifica<br>autenticação} C -->|Não autenticado| D[Executa login<br>edugit login] C -->|Já autenticado| E[Valida estrutura<br>do código] D --> E E --> F{Validação aprovada?} F -->|Não| G[Exibe erro específico<br>Ex: “Função X não encontrada”] F -->|Sim| H[Compacta e envia<br>código para servidor] G --> B H --> I[Servidor recebe<br>e valida submissão] I --> J[Executa testes<br>unitários em container Docker] J --> K[Gera resultado<br>dos testes] K --> L[Exibe feedback<br>imediato no terminal] L --> M[Atualiza status<br>no Moodle] M --> N[🎉 Submissão<br>concluída com sucesso!] %% Estilização style A fill:#e1f5fe style B fill:#f3e5f5 style L fill:#c8e6c9 style N fill:#4caf50,color:white style G fill:#ffcdd2
flowchart TD A[Aluno: edugit baixar atividade1] --> B[Busca template do professor] B --> C[Download do código base<br>para pasta local] C --> D[Estrutura recebida:<br>atividade1.py<br>README.md<br>testes_unitarios.py] D --> E[Aluno abre editor<br>e analisa código] E --> F[Identifica funções<br>incompletas TODO] F --> G[Desenvolve solução<br>nas áreas marcadas] G --> H[Teste local opcional<br>edugit testar-local] H --> I{Testes passam<br>localmente?} I -->|Não| G I -->|Sim| J[Envio para correção<br>edugit enviar atividade1] J --> K[Validação automática<br>do formato] K --> L[Execução em container<br>Docker seguro] L --> M[Feedback imediato<br>com detalhes] M --> N{Submissão<br>bem-sucedida?} N -->|Não| O[Corrigir problemas<br>e reenviar] N -->|Sim| P[🎉 Código aceito!<br>Nota no Moodle] O --> G %% Estilos style A fill:#e1f5fe style C fill:#f3e5f5 style G fill:#fff9c4 style H fill:#ffecb3 style P fill:#4caf50,color:white style O fill:#ffcdd2
flowchart LR P[Professor] --> C[Cria template<br>com TODOs] C --> U[Upload para<br>sistema EduGit] U --> D[Disponibiliza para<br>download dos alunos] D --> S[Monitora submissões<br>em tempo real] S --> F[Feedback automático<br>para alunos]
Download do template: edugit baixar calculadora_basica
Navega para pasta: cd calculadora_basica
Abre no editor (exemplo): code atividade1.py (Desenvolve a solução - aluno implementa as funções TODOs)
Testa localmente (opcional): edugit testar
Envia para correção: edugit enviar calculadora_basica